package services

import (
	"crypto/rand"
	"domain-system/models"
	"errors"
	"fmt"
	"log"
	"math/big"
	"net/mail"
	"strings"
	"time"

	"github.com/golang-jwt/jwt/v5"
	"github.com/nyaruka/phonenumbers"
	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"
)

// AuthService 认证服务
type AuthService struct {
	db            *gorm.DB
	jwtSecret     string
	openIMService *OpenIMService
}

// NewAuthService 创建认证服务实例
func NewAuthService(db *gorm.DB, jwtSecret string, openIMService *OpenIMService) *AuthService {
	return &AuthService{
		db:            db,
		jwtSecret:     jwtSecret,
		openIMService: openIMService,
	}
}

// ========== 请求和响应结构体 ==========

// RegisterRequest 注册请求结构
type RegisterRequest struct {
	Phone    string `json:"phone" binding:"required"`
	Password string `json:"password" binding:"required,min=6"`
	Username string `json:"username" binding:"required,min=2,max=50"`
	Nickname string `json:"nickname"`
	Email    string `json:"email"`
	AreaCode string `json:"area_code"`
	Country  string `json:"country"`
	City     string `json:"city"`
}

// RegisterResponse 注册响应结构
type RegisterResponse struct {
	UserID       string `json:"user_id"`
	Username     string `json:"username"`
	Nickname     string `json:"nickname"`
	Phone        string `json:"phone"`
	IMToken      string `json:"im_token,omitempty"`
	ChatToken    string `json:"chat_token,omitempty"`
	OpenimUserId string `json:"openim_user_id,omitempty"`
	Token        string `json:"token"`
	Message      string `json:"message"`
}

// LoginRequest 登录请求结构体
type LoginRequest struct {
	Phone       string `json:"phone"`
	Email       string `json:"email"`
	Password    string `json:"password" binding:"required"`
	AreaCode    string `json:"area_code"`              // 新增区号字段
	LoginOpenIM *bool  `json:"login_openim,omitempty"` // 控制是否登录OpenIM服务器，默认为true
	Platform    int    `json:"platform,omitempty"`     // 新增：客户端传入的平台类型
}

type VerificationCodeLoginRequest struct {
	Phone            string `json:"phone" binding:"required"`
	VerificationCode string `json:"verification_code" binding:"required"`
	AreaCode         string `json:"area_code"`              // 新增区号字段
	LoginOpenIM      *bool  `json:"login_openim,omitempty"` // 控制是否登录OpenIM服务器，默认为true
	Platform         int    `json:"platform,omitempty"`     // 新增：客户端传入的平台类型
}

// AuthResponse 认证响应结构
type AuthResponse struct {
	User      *models.User `json:"user"`
	Token     string       `json:"token"`
	IMToken   string       `json:"im_token,omitempty"`
	ChatToken string       `json:"chat_token,omitempty"`
	Message   string       `json:"message,omitempty"`
}

// areaCode 传入如 "+86"、"86"、"+1" 等；phone 传本地位数号码（不含国家码）
func (s *AuthService) ValidateByAreaCode(phone, areaCode string) bool {
	ac := strings.TrimSpace(areaCode)
	if ac != "" && !strings.HasPrefix(ac, "+") {
		ac = "+" + ac
	}
	// 构造 E.164 号码，直接解析（号码以 + 开头时 region 可传空字符串）
	full := ac + phone
	num, err := phonenumbers.Parse(full, "")
	if err != nil {
		return false
	}
	return phonenumbers.IsValidNumber(num)
}

// ValidateVerificationCode 验证验证码
func (s *AuthService) ValidateVerificationCode(code string) error {
	// 目前使用默认验证码666
	if code != "666666" {
		return errors.New("验证码错误")
	}
	return nil
}

// GenerateUserID 生成唯一用户ID
func (s *AuthService) GenerateUserID() (string, error) {
	for i := 0; i < 10; i++ {
		n, err := rand.Int(rand.Reader, big.NewInt(100000000))
		if err != nil {
			return "", fmt.Errorf("生成随机数失败: %v", err)
		}
		userID := fmt.Sprintf("user_%08d", n.Int64())

		// 检查唯一性
		var count int64
		if err := s.db.Model(&models.User{}).Where("user_id = ?", userID).Count(&count).Error; err != nil {
			return "", fmt.Errorf("检查用户ID唯一性失败: %v", err)
		}
		if count == 0 {
			return userID, nil
		}
	}
	return "", errors.New("生成用户ID失败，请重试")
}

// ========== 密码处理 ==========

// HashPassword 加密密码
func (s *AuthService) HashPassword(password string) (string, error) {
	hashed, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return "", fmt.Errorf("密码加密失败: %v", err)
	}
	return string(hashed), nil
}

// CheckPassword 验证密码
func (s *AuthService) CheckPassword(hashedPassword, password string) error {
	if err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password)); err != nil {
		return errors.New("密码错误")
	}
	return nil
}

// GenerateJWT 生成JWT令牌
func (s *AuthService) GenerateJWT(userID string) (string, error) {
	claims := jwt.MapClaims{
		"user_id": userID,
		"exp":     time.Now().Add(time.Hour * 24 * 7).Unix(), // 7天过期
		"iat":     time.Now().Unix(),
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	signedToken, err := token.SignedString([]byte(s.jwtSecret))
	if err != nil {
		return "", fmt.Errorf("生成JWT令牌失败: %v", err)
	}
	return signedToken, nil
}

// ValidateJWT 验证JWT令牌
func (s *AuthService) ValidateJWT(tokenString string) (string, error) {
	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
		}
		return []byte(s.jwtSecret), nil
	})

	if err != nil {
		return "", fmt.Errorf("令牌解析失败: %v", err)
	}

	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
		if userID, ok := claims["user_id"].(string); ok {
			return userID, nil
		}
	}

	return "", errors.New("无效的令牌")
}

// checkUserExists 检查用户是否存在 - 支持区号
func (s *AuthService) checkUserExists(username, phone, areaCode string) error {
	var existingUser models.User

	// 检查用户名
	err := s.db.Where("username = ?", username).First(&existingUser).Error
	if err == nil {
		return errors.New("用户名已存在")
	}
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return fmt.Errorf("检查用户名失败: %v", err)
	}

	// 检查手机号 - 支持区号+手机号组合
	if areaCode != "" {
		// 使用区号+手机号组合查找
		err = s.db.Where("phone = ? AND area_code = ?", phone, areaCode).First(&existingUser).Error
	} else {
		// 兼容旧版本，只使用手机号查找
		err = s.db.Where("phone = ?", phone).First(&existingUser).Error
	}

	if err == nil {
		return errors.New("手机号已注册")
	}
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return fmt.Errorf("检查手机号失败: %v", err)
	}
	fmt.Println("checkUserExists success")
	return nil
}

// handleOpenIMRegistration 处理OpenIM注册
func (s *AuthService) handleOpenIMRegistration(user *models.User) (string, string, string) {
	if s.openIMService == nil {
		return "", "", ""
	}

	cert, err := s.openIMService.RegisterUser(user.Nickname,
		user.Password, user.Phone, user.Email, user.AreaCode)
	if err != nil {
		log.Printf("OpenIM注册失败: %v", err)
		return "", "", ""
	}

	if cert.UserID != "" {
		if err := s.db.Model(user).Update("OpenIMUserID", cert.UserID).Error; err != nil {
			log.Printf("更新OpenIM用户ID失败: %v", err)
		}
	}

	fmt.Println(cert.IMToken, cert.ChatToken, cert.UserID)
	return cert.IMToken, cert.ChatToken, cert.UserID
}

// handleOpenIMLogin 处理OpenIM登录 - 支持区号
func (s *AuthService) handleOpenIMLogin(user *models.User, password, areaCode string) (string, string, string) {
	if s.openIMService == nil || user.OpenIMUserID == "" {
		return "", "", "登录成功"
	}

	// 尝试使用手机号和区号登录OpenIM
	cert, err := s.openIMService.LoginToOpenIM(user.Phone, password, areaCode)
	if err != nil {
		log.Printf("OpenIM登录失败: %v", err)
		return "", "", "登录成功，但IM服务连接失败"
	}
	return cert.IMToken, cert.ChatToken, "登录成功"
}

// handleOpenIMLoginWithVerificationCode 处理验证码登录时的OpenIM登录
func (s *AuthService) handleOpenIMLoginWithVerificationCode(user *models.User, areaCode string, platform int) (string, string, string) {
	if s.openIMService == nil || user.OpenIMUserID == "" {
		fmt.Println("openIMService is nil or user.OpenIMUserID is empty")
		return "", "", "验证码登录成功"
	}

	// 设置默认区号
	if areaCode == "" {
		areaCode = "+86"
	}

	// 验证码登录时，使用默认验证码登录OpenIM
	// 优先使用手机号登录，如果失败则尝试使用用户ID
	loginOptions := []string{user.Phone, user.UserID, user.Email}

	for _, loginID := range loginOptions {
		if loginID == "" {
			continue
		}

		// 尝试使用验证码登录
		if cert, err := s.openIMService.LoginToOpenIMWithVerificationCodeWithPlatform(loginID, "666666",
			areaCode, platform); err == nil {
			return cert.IMToken, cert.ChatToken, "验证码登录成功"
		} else {
			log.Printf("使用 %s 进行OpenIM验证码登录失败: %v", loginID, err)
		}
	}

	// 如果验证码登录都失败，记录日志但不影响主要登录流程
	log.Printf("验证码登录时OpenIM登录失败，用户: %s，区号: %s", user.UserID, areaCode)
	return "", "", "验证码登录成功，IM服务连接失败"
}

// Register 用户注册
func (s *AuthService) Register(req *RegisterRequest) (*RegisterResponse, error) {
	// 1. 输入验证
	if req.Username == "" || req.Password == "" {
		return nil, errors.New("用户名和密码不能为空")
	}

	if !s.ValidateByAreaCode(req.Phone, req.AreaCode) {
		return nil, errors.New("手机号格式错误")
	}

	// 设置默认区号
	areaCode := req.AreaCode
	if areaCode == "" {
		areaCode = "+86" // 默认中国区号
	}

	// 2. 检查用户是否已存在 - 传入区号
	if err := s.checkUserExists(req.Username, req.Phone, areaCode); err != nil {
		return nil, err
	}

	// 3. 生成用户ID和加密密码
	userID, err := s.GenerateUserID()
	if err != nil {
		return nil, err
	}

	hashedPassword, err := s.HashPassword(req.Password)
	if err != nil {
		return nil, err
	}

	// 4. 设置默认昵称
	nickname := req.Nickname
	if nickname == "" {
		nickname = req.Username
	}

	// 5. 创建用户记录
	user := &models.User{
		UserID:   userID,
		Username: req.Username,
		Nickname: nickname,
		Phone:    req.Phone,
		AreaCode: areaCode,
		Email:    req.Email,
		Password: hashedPassword,
		Country:  req.Country,
		City:     req.City,
		IsActive: true,
	}

	if err := s.db.Create(user).Error; err != nil {
		// 检查是否是UNIQUE约束错误
		if strings.Contains(err.Error(), "UNIQUE constraint failed: users.phone") {
			return nil, errors.New("手机号已注册")
		}
		if strings.Contains(err.Error(), "UNIQUE constraint failed: users.username") {
			return nil, errors.New("用户名已存在")
		}
		return nil, fmt.Errorf("创建用户失败: %v", err)
	}

	// 6. 生成JWT令牌
	token, err := s.GenerateJWT(userID)
	if err != nil {
		return nil, err
	}

	// 7. 处理OpenIM注册
	imToken, chatToken, openimUserId := s.handleOpenIMRegistration(user)

	return &RegisterResponse{
		UserID:       userID,
		Username:     req.Username,
		Nickname:     nickname,
		Phone:        req.Phone,
		IMToken:      imToken,
		ChatToken:    chatToken,
		OpenimUserId: openimUserId,
		Token:        token,
		Message:      "注册成功",
	}, nil
}

// RegisterByEmailRequest 邮箱注册请求
type RegisterByEmailRequest struct {
	Email    string `json:"email" binding:"required"`
	Password string `json:"password" binding:"required,min=6"`
	Username string `json:"username" binding:"required,min=2,max=50"`
	Nickname string `json:"nickname"`
	Country  string `json:"country"`
	City     string `json:"city"`
}

// RegisterByEmail 邮箱注册
func (s *AuthService) RegisterByEmail(req *RegisterByEmailRequest) (*RegisterResponse, error) {
	// 1. 输入验证
	if req.Username == "" || req.Password == "" || req.Email == "" {
		return nil, errors.New("用户名、密码、邮箱不能为空")
	}
	if _, err := mail.ParseAddress(strings.TrimSpace(req.Email)); err != nil {
		return nil, errors.New("邮箱格式错误")
	}

	// 2. 检查用户是否已存在（用户名、邮箱唯一）
	var existingUser models.User
	if err := s.db.Where("username = ?", req.Username).First(&existingUser).Error; err == nil {
		return nil, errors.New("用户名已存在")
	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fmt.Errorf("检查用户名失败: %v", err)
	}
	if err := s.db.Where("email = ?", req.Email).First(&existingUser).Error; err == nil {
		return nil, errors.New("邮箱已注册")
	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fmt.Errorf("检查邮箱失败: %v", err)
	}

	// 3. 生成用户ID和加密密码
	userID, err := s.GenerateUserID()
	if err != nil {
		return nil, err
	}
	hashedPassword, err := s.HashPassword(req.Password)
	if err != nil {
		return nil, err
	}

	// 4. 默认昵称
	nickname := req.Nickname
	if nickname == "" {
		nickname = req.Username
	}

	// 5. 创建用户记录（不含手机号/区号）
	user := &models.User{
		UserID:   userID,
		Username: req.Username,
		Nickname: nickname,
		Email:    req.Email,
		Password: hashedPassword,
		Country:  req.Country,
		City:     req.City,
		IsActive: true,
	}
	if err := s.db.Create(user).Error; err != nil {
		if strings.Contains(err.Error(), "UNIQUE constraint failed: users.email") {
			return nil, errors.New("邮箱已注册")
		}
		if strings.Contains(err.Error(), "UNIQUE constraint failed: users.username") {
			return nil, errors.New("用户名已存在")
		}
		return nil, fmt.Errorf("创建用户失败: %v", err)
	}

	// 6. 生成JWT令牌
	token, err := s.GenerateJWT(userID)
	if err != nil {
		return nil, err
	}

	// 7. 处理OpenIM注册（仅邮箱）
	imToken, chatToken, openimUserId := s.handleOpenIMRegistration(user)

	return &RegisterResponse{
		UserID:       userID,
		Username:     req.Username,
		Nickname:     nickname,
		Phone:        "",
		IMToken:      imToken,
		ChatToken:    chatToken,
		OpenimUserId: openimUserId,
		Token:        token,
		Message:      "注册成功",
	}, nil
}

func (s *AuthService) Login(req *LoginRequest) (*AuthResponse, error) {
	var user models.User
	var err error

	// 验证输入：必须提供手机号或邮箱
	if req.Phone == "" && req.Email == "" {
		return nil, errors.New("请提供手机号或邮箱")
	}

	// 如果提供了邮箱，优先使用邮箱登录
	if req.Email != "" {
		// 验证邮箱格式
		if _, err := mail.ParseAddress(req.Email); err != nil {
			return nil, errors.New("邮箱格式错误")
		}

		// 通过邮箱查找用户
		err = s.db.Where("email = ? AND is_active = ?", req.Email, true).First(&user).Error
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户不存在或已被禁用")
		}
		if err != nil {
			return nil, fmt.Errorf("查询用户失败: %v", err)
		}
	} else {
		// 使用手机号登录（原有逻辑）
		// 1. 验证手机号格式
		if !s.ValidateByAreaCode(req.Phone, req.AreaCode) {
			return nil, errors.New("手机号格式错误")
		}

		// 设置默认区号
		areaCode := req.AreaCode
		if areaCode == "" {
			areaCode = "+86" // 默认中国区号
		}

		// 2. 查找用户 - 支持区号
		if req.AreaCode != "" {
			// 使用区号+手机号查找
			err = s.db.Where("phone = ? AND area_code = ? AND is_active = ?", req.Phone, areaCode, true).First(&user).Error
		} else {
			// 兼容旧版本，只使用手机号查找
			err = s.db.Where("phone = ? AND is_active = ?", req.Phone, true).First(&user).Error
		}

		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户不存在或已被禁用")
		}
		if err != nil {
			return nil, fmt.Errorf("查询用户失败: %v", err)
		}
	}

	// 3. 验证密码
	if err := s.CheckPassword(user.Password, req.Password); err != nil {
		return nil, err
	}

	// 4. 生成JWT令牌
	token, err := s.GenerateJWT(user.UserID)
	if err != nil {
		return nil, err
	}
	fmt.Println("user", user)

	// 5. 处理OpenIM登录 - 改为使用验证码登录方式
	var areaCode string
	if req.Email != "" {
		// 邮箱登录时使用用户存储的区号
		areaCode = user.AreaCode
	} else {
		// 手机号登录时使用请求中的区号
		areaCode = req.AreaCode
		if areaCode == "" {
			areaCode = "+86"
		}
	}
	platform := req.Platform
	if platform == 0 {
		platform = 2
	}
	imToken, chatToken, message := s.handleOpenIMLoginWithVerificationCode(&user, areaCode, platform)

	return &AuthResponse{
		User:      &user,
		Token:     token,
		IMToken:   imToken,
		ChatToken: chatToken,
		Message:   message,
	}, nil
}

// LoginWithVerificationCode 验证码登录
func (s *AuthService) LoginWithVerificationCode(req *VerificationCodeLoginRequest) (*AuthResponse, error) {
	// 1. 验证手机号格式
	if !s.ValidateByAreaCode(req.Phone, req.AreaCode) {
		return nil, errors.New("手机号格式错误")
	}

	// 2. 验证验证码
	if err := s.ValidateVerificationCode(req.VerificationCode); err != nil {
		return nil, err
	}

	// 3. 查找用户
	var user models.User
	err := s.db.Where("phone = ? AND is_active = ?", req.Phone, true).First(&user).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, errors.New("用户不存在或已被禁用")
	}
	if err != nil {
		return nil, fmt.Errorf("查询用户失败: %v", err)
	}

	// 4. 生成JWT令牌
	token, err := s.GenerateJWT(user.UserID)
	if err != nil {
		return nil, err
	}

	// 5. 检查是否需要登录OpenIM（默认为true）
	shouldLoginOpenIM := true
	if req.LoginOpenIM != nil {
		shouldLoginOpenIM = *req.LoginOpenIM
	}

	var imToken, chatToken, message string
	if shouldLoginOpenIM {
		platform := req.Platform
		if platform == 0 {
			platform = 2
		}
		// 处理OpenIM登录（验证码登录时使用用户的原始密码）
		imToken, chatToken, message = s.handleOpenIMLoginWithVerificationCode(&user, req.AreaCode, platform)
		if imToken == "" || chatToken == "" {
			return nil, errors.New("OpenIM登录失败")
		}
	} else {
		message = "验证码登录成功（未登录OpenIM）"
	}

	return &AuthResponse{
		User:      &user,
		Token:     token,
		IMToken:   imToken,
		ChatToken: chatToken,
		Message:   message,
	}, nil
}

func (s *AuthService) SendVerificationCode(phone, areaCode string) error {
	// 1. 验证手机号格式
	if !s.ValidateByAreaCode(phone, areaCode) {
		return errors.New("手机号格式错误")
	}

	// 2. 检查用户是否存在（可以根据区号和手机号查询）
	// var user models.User
	// err := s.db.Where("phone = ? AND area_code = ? AND is_active = ?", phone, areaCode, true).First(&user).Error
	// if errors.Is(err, gorm.ErrRecordNotFound) {
	// 	return errors.New("用户不存在")
	// }
	// if err != nil {
	// 	return fmt.Errorf("查询用户失败: %v", err)
	// }

	// 3. 集成短信服务发送验证码
	// 构建完整的国际号码格式
	// fullPhone := areaCode + phone
	log.Printf("向手机号 %s (区号: %s) 发送验证码: 666", phone, areaCode)

	// TODO: 这里可以集成真实的短信服务
	// 例如：阿里云短信、腾讯云短信等
	// return s.smsService.SendSMS(fullPhone, "验证码: 666")

	return nil
}

func (s *AuthService) SendEmailVerificationCode(email string) error {
	addr, err := mail.ParseAddress(strings.TrimSpace(email))
	if err != nil || addr.Address == "" {
		return errors.New("邮箱格式错误")
	}
	log.Printf("向邮箱 %s 发送验证码: 666", addr.Address)
	// TODO: 集成真实的邮件服务（如SMTP、第三方邮件服务）发送验证码
	return nil
}

// GetUserByID 根据用户ID获取用户信息
func (s *AuthService) GetUserByID(userID string) (*models.User, error) {
	var user models.User
	err := s.db.Where("user_id = ? AND is_active = ?", userID, true).First(&user).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, errors.New("用户不存在")
	}
	if err != nil {
		return nil, fmt.Errorf("查询用户失败: %v", err)
	}
	return &user, nil
}

// DeactivateUser 注销用户账户
func (s *AuthService) DeactivateUser(userID string) error {
	if err := s.db.Model(&models.User{}).Where("user_id = ?", userID).Update("is_active", false).Error; err != nil {
		return fmt.Errorf("注销用户失败: %v", err)
	}
	return nil
}

// Logout 用户注销
func (s *AuthService) Logout(userID string) error {
	// 简单实现：客户端删除令牌即可
	// 复杂实现：可以维护令牌黑名单
	return nil
}

// ResetPasswordRequest 重置密码请求结构
type ResetPasswordRequest struct {
	Phone            string `json:"phone"`
	Email            string `json:"email"`
	VerificationCode string `json:"verification_code" binding:"required"`
	NewPassword      string `json:"new_password" binding:"required,min=6"`
	AreaCode         string `json:"area_code"`
}

// ResetPasswordResponse 重置密码响应结构
type ResetPasswordResponse struct {
	Message string `json:"message"`
}

// ValidateEmail 验证邮箱格式
func (s *AuthService) ValidateEmail(email string) bool {
	_, err := mail.ParseAddress(email)
	return err == nil
}

// ResetPassword 重置密码
func (s *AuthService) ResetPassword(req *ResetPasswordRequest) (*ResetPasswordResponse, error) {
	// 验证输入参数：必须提供手机号或邮箱中的一个
	if req.Phone == "" && req.Email == "" {
		return nil, errors.New("请提供手机号或邮箱")
	}

	if req.Phone != "" && req.Email != "" {
		return nil, errors.New("请只提供手机号或邮箱中的一个")
	}

	// 根据输入类型进行验证
	if req.Phone != "" {
		// 验证手机号格式
		if !s.ValidateByAreaCode(req.Phone, req.AreaCode) {
			return nil, errors.New("手机号格式错误")
		}
	} else if req.Email != "" {
		// 验证邮箱格式
		if !s.ValidateEmail(req.Email) {
			return nil, errors.New("邮箱格式错误")
		}
	}

	// 验证验证码
	if err := s.ValidateVerificationCode(req.VerificationCode); err != nil {
		return nil, err
	}

	// 查找用户
	var user models.User
	var err error

	if req.Phone != "" {
		// 通过手机号查找用户
		phoneWithArea := req.Phone
		if req.AreaCode != "" {
			phoneWithArea = req.AreaCode + req.Phone
		}
		err = s.db.Where("phone = ? OR phone = ?", req.Phone, phoneWithArea).First(&user).Error
	} else {
		// 通过邮箱查找用户
		err = s.db.Where("email = ?", req.Email).First(&user).Error
	}

	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.New("用户不存在")
		}
		return nil, fmt.Errorf("查询用户失败: %v", err)
	}

	// 加密新密码
	hashedPassword, err := s.HashPassword(req.NewPassword)
	if err != nil {
		return nil, fmt.Errorf("密码加密失败: %v", err)
	}

	// 更新密码
	err = s.db.Model(&user).Update("password", hashedPassword).Error
	if err != nil {
		return nil, fmt.Errorf("更新密码失败: %v", err)
	}

	return &ResetPasswordResponse{
		Message: "密码重置成功",
	}, nil
}

// SendResetPasswordCode 发送重置密码验证码
func (s *AuthService) SendResetPasswordCode(phone, areaCode string) error {
	// 验证手机号格式
	if !s.ValidateByAreaCode(phone, areaCode) {
		return errors.New("手机号格式错误")
	}

	// 检查用户是否存在
	var user models.User
	phoneWithArea := phone
	if areaCode != "" {
		phoneWithArea = areaCode + phone
	}

	err := s.db.Where("phone = ? OR phone = ?", phone, phoneWithArea).First(&user).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New("用户不存在")
		}
		return fmt.Errorf("查询用户失败: %v", err)
	}

	// 这里应该调用短信服务发送验证码
	// 目前使用模拟实现
	log.Printf("发送重置密码验证码到手机号: %s, 验证码: 666666", phone)

	return nil
}
